// 购物车模块
import { checkAllCart, deleteCart, findCartList, getNewCartGoods, insertCart, mergeCart, updateCart } from '@/api/cart'

export default {
  namespaced: true,
  state () {
    return {
      // 购物车商品内容
      list: []
    }
  },
  getters: {
    // 有效商品列表
    validList (state) {
      // 有效商品：库存大于0  有效标识:isEffective：true
      return state.list.filter(goods => goods.stock > 0 && goods.isEffective)
    },
    // 有效商品总件数
    validTotal (state, getters) {
      return getters.validList.reduce((p, c) => p + c.count, 0)
    },
    // 有效商品总金额
    validAmount (state, getters) {
      // 处理小数的方法是：先让金额乘以100然后总体计算结果除以100
      return getters.validList.reduce((p, c) => p + c.nowPrice * 100 * c.count, 0) / 100
    },
    // 无效商品
    invalidList (state) {
      // 无效商品：库存<=0  有效标识:isEffective：false
      return state.list.filter(goods => !(goods.stock > 0 && goods.isEffective))
    },
    // 选中商品列表
    selectedList (state, getters) {
      return getters.validList.filter(item => item.selected)
    },
    // 选中商品件数
    selectedTotal (state, getters) {
      return getters.selectedList.reduce((p, c) => p + c.count, 0)
    },
    // 选中商品总金额
    selectedAmount (state, getters) {
      // 处理小数的方法是：先让金额乘以100然后总体计算结果除以100
      return getters.selectedList.reduce((p, c) => p + c.nowPrice * 100 * c.count, 0) / 100
    },
    // 是否全选
    isCheckAll (state, getters) {
      // 有效商品长度=选中商品长度
      return getters.validList.length !== 0 && getters.validList.length === getters.selectedList.length
    }
  },
  mutations: {
    // 加入购物车
    insertCart (state, payload) {
      // 需要哪些字段：约定加入购物车字段必须与后端保持一致
      // 字段有： id（商品id） skuId name attrsText picture price nowPrice selected stock count isEffective
      // 插入数据的规则：
      // 1. 先查找是否有相同商品
      // 2. 如果有相同的商品，查询它的数量，累加到payload上，再保持到最新位置，原来的商品需要删除
      // 3. 如果没有相同商品，保存再最新位置即可
      const sameIndex = state.list.findIndex(goods => goods.skuId === payload.skuId)
      if (sameIndex > -1) {
        // 有相同商品
        const count = state.list[sameIndex].count
        // console.log(state.list[sameIndex])
        payload.count += count
        // 删除原来得
        state.list.splice(sameIndex, 1)
      }
      // 追加新的
      state.list.unshift(payload)
    },
    // 修改商品
    updateCart (state, goods) {
      // goods 商品信息： nowPrice stock isEffective
      // goods商品字段不固定，传入哪些字段就修改哪些字段，但是字段的值合理才能修改（不合理：null,'')
      // goods商品对象必须有skuid才能进行修改
      const updateGoods = state.list.find(item => item.skuId === goods.skuId)
      for (const key in goods) {
        if (goods[key] !== undefined && goods[key] != null && goods[key] !== '') {
          // 合理才修改
          updateGoods[key] = goods[key]
        }
      }
    },
    // 删除商品
    deleteCart (state, skuId) {
      const index = state.list.findIndex(item => item.skuId === skuId)
      state.list.splice(index, 1)
    },
    // payload为空则为清空购物车，有值为设置购物车（数组）
    setCart (state, payload) {
      state.list = payload
    }
  },
  // 区分两种情况：已经登录，未登录
  actions: {
    //  全选与取消全选
    checkAllCart (ctx, selected) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已经登录
          checkAllCart({
            selected: selected
          }).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 未登录
          ctx.getters.validList.forEach(goods => {
            ctx.commit('updateCart', {
              skuId: goods.skuId,
              selected
            })
          })
          resolve()
        }
      })
    },
    // 加入购物车
    insertCart (ctx, payload) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已经登录
          // api
          insertCart({
            skuId: payload.skuId,
            count: payload.count
          }).then(data => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 未登录
          ctx.commit('insertCart', payload)
          resolve()
        }
      })
    },
    // 获取商品列表
    findCart (ctx, payload) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已经登录
          findCartList().then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 未登录
          // 同时发送请求（有几个商品发几个请求）等所有请求成功，一并修改本地数据
          // promise.all(promise数组).then((dataList)=>{一并修改本地数据})  ===> 同时发送请求，得到所有成功结果
          // Promise.resolve()  Promise.reject()  new Promise()
          // Promise.race(promise数组).then((data)=>{}) 同时发送请求，最快的请求成功，得到成功结果
          const promiseArr = ctx.state.list.map(goods => {
            return getNewCartGoods(goods.skuId)
          })
          // dataList是成功结果激活，数据顺序和promiseArr顺序一致，它又是根据state.list而来
          Promise.all(promiseArr).then(dataList => {
            // 更新本地购物车
            dataList.forEach((data, index) => {
              ctx.commit('updateCart', { skuId: ctx.state.list[index].skuId, ...data.result })
            })
            resolve()
          })
          resolve()
        }
      })
    },
    // 删除商品 payload就是skuId
    deleteCart (ctx, payload) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已经登录
          deleteCart([payload]).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 未登录
          ctx.commit('deleteCart', payload)
          resolve()
        }
      })
    },
    // 修改购物车（选中状态，数量）
    updateCart (ctx, payload) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已经登录
          updateCart(payload).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 未登录
          ctx.commit('updateCart', payload)
          resolve()
        }
      })
    },
    // 批量删除, 支持清空无效商品
    batchDeleteCart (ctx, isClear) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已经登录
          const ids = ctx.getters[isClear ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          deleteCart(ids).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCart', data.result)
            resolve()
          })
        } else {
          // 未登录
          // 找出选中的商品列表,遍历调用删除的mutactions
          // isClear为true表示清空无效商品; false表示删除选中商品
          ctx.getters[isClear ? 'invalidList' : 'selectedList'].forEach(item => {
            ctx.commit('deleteCart', item.skuId)
          })
          resolve()
        }
      })
    },
    // 修改规格
    updateCartSku (ctx, {
      oldSkuId,
      newSku
    }) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已经登录(跟本地逻辑一样)
          // 1.找出旧的商品信息
          const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
          // 2.删除旧的商品数据

          deleteCart([oldGoods.skuId]).then(() => {
            // 3.根据新的sku信息和旧的商品信息，合并成一条新的购物车商品数据
            // 4.添加新的商品
            return insertCart({
              skuId: newSku.skuId,
              count: oldGoods.count
            }).then(() => {
              return findCartList()
            }).then(data => {
              ctx.commit('setCart', data.result)
              resolve()
            })
          })
        } else {
          // 未登录
          // 1.找出旧的商品信息
          const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
          // 2.删除旧的商品数据
          ctx.commit('deleteCart', oldSkuId)
          // 3.根据新的sku信息和旧的商品信息，合并成一条新的购物车商品数据
          const {
            skuId,
            price: nowPrice,
            specText: attrsText,
            inventory: stock
          } = newSku
          const newGoods = {
            ...oldGoods,
            skuId,
            nowPrice,
            attrsText,
            stock
          }
          // 4.添加新的商品
          ctx.commit('insertCart', newGoods)
          resolve()
        }
      })
    },
    // 合并购物车, 不需要区分是否登录
    async mergeCart (ctx) {
      const cartList = ctx.state.list.map(goods => {
        return {
          skuId: goods.skuId,
          selected: goods.selected,
          count: goods.count
        }
      })
      // api中的mergeCart
      await mergeCart(cartList)
      // 合并成功
      ctx.commit('setCart', [])
    }
  }
}
